<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <style>
        
    </style>
</head>
<body>
    
</body>
<script>
    // 1. 封装一个函数，实现能对指定数组的指定位置删除数据，并替换成新数据
    //     - 如：fn(arr, 3, "abc")
    //         - 删除arr的索引3的原数据，替换成abc
    //     - 如：fn(arr, 4)
    //         - 只删除arr的索引4的数据，不替换
    function fn(myarr, index, data){
        // 问题的根本点：判断参数的个数
        // if(data === undefined){
        if(arguments.length < 3){
            // 两个参数，删除功能
            for(var i=index;i<myarr.length;i++){
                myarr[i] = myarr[i+1];
            }
            myarr.length -= 1;
        }else{
            // 三个参数，替换功能
            myarr[index] = data;
        }
    }
    // var arr = [5,6,7,8,9];
    // console.log(arr);
    // fn(arr, 2);
    // fn(arr, 2, "abc");
    // fn(arr, 2, undefined);
    // console.log(arr);


    // 2. 使用for循环完成，将数组中的对象中的check为true时的price累加起来
    var arr = [{
        price:100,
        check:true
    },{
        price:200,
        check:false
    },{
        price:90,
        check:false
    },{
        price:50,
        check:true
    }];
    var sum = 0;
    for(var i=0;i<arr.length;i++){
        if( arr[i].check ){
            sum += arr[i].price;
        }
    }
    // console.log(sum);


    // 4. 封装函数，实现数组去重的功能，执行语法：norepeat([5,2,3,3,4,5,4,3,2,2,3,4,4,4])
    //     - [5,2,3,3,4,5,4,3,2,2,3,4,4,4]
    //     - [5,2,3,4]

    // function norepeat(myarr){
    //     // 创建一个新数组
    //     var a = [];
    //     // 遍历老数组
    //     for(var i=0;i<myarr.length;i++){
    //         // 判断新数组中是否存在老数组的数据
    //         if(a.indexOf( myarr[i] ) === -1){
    //             // 如果不存在，添加
    //             a.push( myarr[i] );
    //         }
    //     }
    //     return a;
    // }

    function norepeat(myarr){
        // 依次取出每个数据
        for(var i=0;i<myarr.length;i++){
            // 再一次取出后面所有数据
            for(var j=i+1;j<myarr.length;j++){
                // 将第一次取出的数据，和后面所有数据作比较
                // 发现重复
                if(myarr[i] === myarr[j]){
                    // 删除
                    myarr.splice(j, 1);
                    // 为了防止删除数组数据后，后一个数据向前补位，引起跳过索引的现象
                    // 主动将索引向前移动1
                    j--;
                }
            }
        }
        return myarr;
    }

    // var arr = [5,2,3,3,4,5,4,3,2,2,3,4,4,4,6];
    // console.log(arr);
    // var res = norepeat(arr);
    // console.log(res);
    // console.log(arr);
    // console.log(arr === res);

    // 5. 封装函数，实现统计数组中每个字符出现的次数，将结果以对象的形式展示，执行语法：count(["a","b","a","c","a","c","b","c","c"])
    //     - ["a","b","a","c","a","c","b","c","c"]
    //     - {a:3, b:2, c:4}

    function count(myarr){
        // 准备一个空对象，用来记录出现的次数
        var obj = {};
        // 遍历数组，拿到每个数据
        for(var i=0;i<myarr.length;i++){
            // 将数组中的每个数据，作为对象的键，判断是否存在
            // 不存在：undefined，存在：非0的数字
            if( obj[ myarr[i] ] ){
                // 存在，表示之前记录过，本次重新发现，+1
                obj[ myarr[i] ]++
            }else{
                // 不存在，表示之前没有记录过，本次只记录
                obj[ myarr[i] ] = 1;
            }
        }
        // 返回结果
        return obj;
    }
    // var arr = ["d","a","b","a","c","a","c","b","c","c","d","d","d"];
    // console.log(arr);
    // var res = count(arr);
    // console.log(res);


    // 6. 封装函数，实现有一个排好序的数值数组，要求按照原来的规律插入一个新数值，执行语法：insert([3,5,7,9,12], 8)
    //     - [3,5,7,9,12]
    //     - 插入：8
    //     - [3,5,7,8,9,12]

    function insert(myarr, data){
        // myarr.push(data);
        // myarr.sort(function(a,b){
        //     return a-b;
        // })

        // =======
        // 先找到要插入数据的位置
        // 判断数组中第一个大于要插入数据的数据的位置
        for(var i=0;i<myarr.length;i++){
            if(data < myarr[i]){
                break;
            }
        }
        // 从后向前直到要插入新数据的位置，依次将每个数据都向后移动一位
        for(var j=myarr.length;j>i;j--){
            myarr[j] = myarr[j-1];
        }
        // 将新数据，插入到指定位置
        myarr[i] = data;
    }
    // var arr = [3,5,7,9,12]
    // console.log(arr)
    // insert(arr, 8)
    // console.log(arr)

</script>
</html>